package com.os.mybatisplus;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.PaginationInterceptor;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.plugins.pagination.optimize.JsqlParserCountOptimize;
import com.os.dao.UserDao;
import com.os.domain.User;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.ComponentScan;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;

@Controller
@SpringBootApplication
@MapperScan(value={"com.os.dao"})  //扫描mapper，否则会出现bean could not be found.
public class MybatisplusApplication {

    @Resource
    private UserDao userDao;

    //根据id查询
    @RequestMapping("/selectById")
    @ResponseBody
    public User selectById(){
        User user = userDao.selectById(4);
        return user;
    }

    //查询所有
    @RequestMapping("/selectList")
    @ResponseBody
    public List<User> selectList(){
        List<User> userList = userDao.selectList(null);
        return userList;
    }

    //添加
    @RequestMapping("/insert")
    @ResponseBody
    public int insert(){
        User user = new User();
        user.setId(99);
        user.setCnName("中国人");
        user.setUserName("美国人");
        int iNum = userDao.insert(user);
        return iNum;
    }

    @RequestMapping("/updateById")
    @ResponseBody
    public int updateById(){
        User user = new User();
        user.setId(99);
        user.setCnName("中国人");
        user.setUserName("美国人-中国人");
        int iNum = userDao.updateById(user);
        return iNum;
    }

    @RequestMapping("/deleteById")
    @ResponseBody
    public int deleteById(){
        int iNum = userDao.deleteById(99);
        return iNum;
    }

    /**
     * 实现复杂查询，查询名字中包含t的人员信息
     * selectOne查询一个方法
     * selectOne需要一个Wrapper对象，实际上是需要一个条件
     *
     * 条件是，查询名字中为Matt
     * sql where user_name = Matt
     * 需要吧sql的条件，封装到Wrapper对象中
     * 将封装了条件的对象，给selectOne
     * Wrapper对象条件构造器，将sql的条件写入到java对象中
     * 将封装了条件的对象 给 selectOne
     *
     * Wrapper对象条件构造器，将sql的条件，写入到java对象中
     * QueryWrapper 查询条件构造器
     * UpdateWrapper 更新条件构造器
     *
     */
    @RequestMapping("/selectByQueryWrapper")
    @ResponseBody
    public User selectByQueryWrapper(){
        //1、创造一个查询条件构造器 泛型 为要查询数据的实体类型
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //2将where user_name = Matt等值查询 这个条件封装到 条件构造器
        queryWrapper.eq("user_name", "Matt");
        //3、通过条件构造器 查询
        User user = userDao.selectOne(queryWrapper);
        return user;
    }

    /**
     * 查询名字为Matt 或者 email中含有hotmail 的人员
     * sql user_name = Matt or email like hotmail
     * or 和 and 怎么构建？
     * @return
     */
    @RequestMapping("/selectByQueryWrapper1")
    @ResponseBody
    public List<User> selectByQueryWrapper1(){
        //1、创造一个查询条件构造器 泛型 为要查询数据的实体类型
        QueryWrapper<User> queryWrapper = new QueryWrapper<>();
        //2构造条件 条件构造器的方法第一个参数基本上都是字段名
        queryWrapper.eq("user_name", "Matt")
                .or()
                .like("email", "hotmail");
        //3、查询
        List<User> userList = userDao.selectList(queryWrapper);
        return userList;
    }

    /**
     * 用法和查询类似
     * 把用户名为Matt的email改为matt@hotmail.com
     * @return
     */
    @RequestMapping("/updateByUpdateWrapper")
    @ResponseBody
    public int updateByUpdateWrapper(){
        //1、创造条件构造器
        UpdateWrapper updateWrapper = new UpdateWrapper();
        //2、创造构造条件
        //where userName = Matt set email = matt@hotmail.com
        updateWrapper.set("email", "matt@hotmail.com");
        updateWrapper.eq("user_name", "Matt");
        //3、使用方法，参数1，一个对象，参数2，条件构造器
        int iNum = userDao.update(null, updateWrapper);
        return iNum;
    }

    //配置分页插件
    /*@Bean
    public PaginationInterceptor paginationInterceptor(){
        PaginationInterceptor paginationInterceptor = new PaginationInterceptor();
        //设置请求的页面大于最页后操作，true调回到首页，false继续请求，默认为false
        //。setOverFlow(false)
        //设置最大但也限制数量，默认500条，-1不受限制
        //.setLimit(500)
        //开启count的join优化，只针对部分left join
        paginationInterceptor.setCountSqlParser(new JsqlParserCountOptimize(true));
        return paginationInterceptor;
    }*/

    /**
     * 测试分页查询
     * 获取第二页数据（页码），煤业显示1条（size）
     */
    @RequestMapping("/queryByPage")
    @ResponseBody
    public HashMap<String, Object> queryByPage(){
        //1、创建一个page对象，封装分页数据
        //创建对象的时候，直接写入分页数据，参数1、页码，参数2、每页条数
        Page<User> userPage = new Page<>(2, 1);
        //2、使用分页查询的方法
        //分页查询的方法selectPage()
        //参数1、IPage分页对象 封装分页信息 封装获取第二页的数据（页码），每页显示2条（size）
        //参数2、条件构造器 可以直接写null
        Page<User> userPageResult = userDao.selectPage(userPage, null);
        //3、从page对象中获取查询到的数据
        //getRecords()获取查询结果
        //getTotal()总条数
        HashMap<String, Object> result = new HashMap<>();
        result.put("总条数", userPageResult.getTotal());
        result.put("记录表", userPageResult.getRecords());
        return result;
    }

    public static void main(String[] args) {
        SpringApplication.run(MybatisplusApplication.class, args);
    }



}
